COMMENT ⊗   VALID 00002 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002	NOTES ON CHESS PROGRAMMING
C00005 ENDMK
C⊗;
NOTES ON CHESS PROGRAMMING


	It is easy to write a depth first search αβ-algorithm in LISP,
because the recursive structure of the task corresponds to the
recursive structure of LISP.  However, writing the program this
way suffers from the usual disadvantages of structured programming
of which LISP is an almost extreme example.  Namely, once the
recursive form of program has been chosen much of the information, e.g.
the other parts of the move tree are hidden on the stack.  Therefore,
slight modifications of depth first search that may involve going
back in the tree, e.g. to see if an effective move can be prevented
involve mafor rewrites or at least great cleverness in noticing
where the modification might go.

	Consider the following kind of unstructured chess program in
LISP.  Auxiliary functions may be recursive, but the main program
has conditional goto's as its only control structure.  This means
that all lists of tasks are explicit, and the control path can
readily be altered.

	As a first approximation imagine that there is plenty of
storage and copying tables has trivial price.  Then every position
that has been examined is simultaneously in memory.  We want to
decide which move to examine next.  The move to be examined is the
move that has the highest expected "information" about what move to
make.  Suppose that every position examined is given an optimistic
value, a pessimistic value and a modal value.  The computation of
the importance of examining a move takes into account its optimistic
and pessimistic value and the modal values of all the other moves.